LINQ এ Join অপারেশন ব্যবহৃত হয় দুটি বা তার বেশি সংগ্রহের মধ্যে সম্পর্ক স্থাপন করার জন্য, যাতে একটি সাধারণ ফিল্ডের ভিত্তিতে ডেটা একত্রিত (combine) করা যায়। SQL-এ যেমন JOIN অপারেশন ব্যবহার করা হয়, ঠিক তেমনি LINQ-এও ডেটাকে একত্রিত বা যোগ করতে Join অপারেটর ব্যবহার করা হয়।

LINQ-এ Join মূলত দুটি সংগ্রহের মধ্যে সম্পর্ক স্থাপন করে তাদের মান যোগ করার জন্য ব্যবহৃত হয়। এর মাধ্যমে আপনি একাধিক টেবিল বা কালেকশনের ডেটাকে একত্রিত করে একটি নতুন আউটপুট তৈরি করতে পারেন।

Join এর মৌলিক গঠন

LINQ-এ Join অপারেটরটির সাধারণ গঠন নিম্নরূপ:

var result = from item1 in collection1
             join item2 in collection2
             on item1.Key equals item2.Key
             select new { item1.Property1, item2.Property2 };

এখানে:

• item1 এবং item2 দুটি সংগ্রহের (বা টেবিলের) প্রতিনিধিত্ব।
• Key হল সেই সাধারণ ফিল্ড যা দুটি সংগ্রহের মধ্যে সম্পর্ক তৈরি করে।
• select new এর মাধ্যমে, আপনি একত্রিত তথ্যের নতুন ফর্ম্যাট নির্ধারণ করতে পারেন।

Inner Join

Inner Join হল সবচেয়ে সাধারণ এবং জনপ্রিয় ধরনের Join অপারেশন, যা দুটি সংগ্রহের মধ্যে common (সাধারণ) মান খুঁজে বের করে তাদের একত্রিত করে। যদি একটি সংগ্রহের কোনো উপাদান অন্য সংগ্রহের সাথে মিলে, তবে সেই উপাদানগুলিই রিটার্ন হবে।

Inner Join উদাহরণ:

ধরা যাক, আমাদের দুটি লিস্ট রয়েছে:

1. Customers (গ্রাহক)
2. Orders (অর্ডার)

আমরা চাই, যে গ্রাহকদের অর্ডার আছে, তাদের নাম এবং অর্ডারের তথ্য একটি একক আউটপুটে দেখাতে।

public class Customer
{
    public int CustomerID { get; set; }
    public string Name { get; set; }
}

public class Order
{
    public int OrderID { get; set; }
    public int CustomerID { get; set; }
    public string Product { get; set; }
}

List<Customer> customers = new List<Customer>
{
    new Customer { CustomerID = 1, Name = "Alice" },
    new Customer { CustomerID = 2, Name = "Bob" },
    new Customer { CustomerID = 3, Name = "Charlie" }
};

List<Order> orders = new List<Order>
{
    new Order { OrderID = 101, CustomerID = 1, Product = "Laptop" },
    new Order { OrderID = 102, CustomerID = 2, Product = "Smartphone" }
};

// Inner Join অপারেশন
var query = from c in customers
            join o in orders on c.CustomerID equals o.CustomerID
            select new { c.Name, o.Product };

foreach (var item in query)
{
    Console.WriteLine($"{item.Name} ordered a {item.Product}");
}

আউটপুট:

Alice ordered a Laptop
Bob ordered a Smartphone

এখানে, Inner Join এর মাধ্যমে Customer এবং Order টেবিলের মধ্যে CustomerID ফিল্ডের ভিত্তিতে সম্পর্ক স্থাপন করা হয়েছে, এবং শুধুমাত্র যাদের অর্ডার রয়েছে, তাদের তথ্য বের করা হয়েছে।

Left Outer Join

Left Outer Join অপারেশনটি মূলত Left Table (বামে থাকা সংগ্রহ) এর সব রেকর্ড এবং Right Table (ডানে থাকা সংগ্রহ) থেকে মেলানো রেকর্ডগুলো নিয়ে আসে। যাদের মিল নেই, তাদের জন্য null রিটার্ন করা হয়।

Left Outer Join উদাহরণ:

এখন আমরা চাই Customers টেবিলের সব গ্রাহক এবং তাদের অর্ডারের তথ্য দেখাতে, যদিও কিছু গ্রাহকের কোনো অর্ডার নাও থাকতে পারে:

// Left Outer Join অপারেশন
var query = from c in customers
            join o in orders on c.CustomerID equals o.CustomerID into customerOrders
            from o in customerOrders.DefaultIfEmpty()
            select new { c.Name, Product = o?.Product ?? "No Order" };

foreach (var item in query)
{
    Console.WriteLine($"{item.Name} ordered a {item.Product}");
}

আউটপুট:

Alice ordered a Laptop
Bob ordered a Smartphone
Charlie ordered a No Order

এখানে, Left Outer Join ব্যবহার করে আমরা Customer টেবিলের সব রেকর্ড এবং তাদের অর্ডারের তথ্য দেখিয়েছি। যাদের কোনো অর্ডার ছিল না, তাদের জন্য "No Order" দেখানো হয়েছে।

Right Outer Join

Right Outer Join হল Left Outer Join এর বিপরীত। এটি Right Table (ডানে থাকা সংগ্রহ) এর সব রেকর্ড এবং Left Table (বামে থাকা সংগ্রহ) থেকে মেলানো রেকর্ডগুলো নিয়ে আসে। যাদের মিল নেই, তাদের জন্য null রিটার্ন করা হয়।

LINQ তে সরাসরি Right Outer Join করার জন্য কোনও অপারেটর নেই, তবে এটি Left Outer Join এর মতো join into এবং DefaultIfEmpty() ব্যবহার করে অর্জন করা সম্ভব।

Cross Join

Cross Join বা Cartesian Product অপারেশনটি দুটি সংগ্রহের প্রতিটি উপাদানকে একে অপরের সাথে মিলিয়ে একটি নতুন আউটপুট তৈরি করে। এটি একটি সংগ্রহের সব উপাদানকে অন্য সংগ্রহের সব উপাদানের সাথে যুক্ত করে।

Cross Join উদাহরণ:

var query = from c in customers
            from o in orders
            select new { c.Name, o.Product };

foreach (var item in query)
{
    Console.WriteLine($"{item.Name} can order {item.Product}");
}

এখানে, Cross Join ব্যবহার করে আমরা Customer এবং Order টেবিলের প্রতিটি রেকর্ডকে একে অপরের সাথে মিলিয়ে সব সম্ভাব্য কম্বিনেশন তৈরি করেছি।

উপসংহার

Join অপারেশন LINQ-এ বিভিন্ন ধরনের সম্পর্ক তৈরি করার জন্য ব্যবহৃত হয়, যেমন Inner Join, Left Outer Join, Right Outer Join এবং Cross Join। এর মাধ্যমে বিভিন্ন টেবিল বা সংগ্রহের ডেটাকে সম্পর্কিত এবং একত্রিত করা সম্ভব হয়। LINQ-এ Join অপারেটর ব্যবহার করা খুবই সহজ, এবং ডেটা একত্রিত করার জন্য এটি একটি শক্তিশালী টুল।

Inner Join হল দুটি ডেটাসেট বা টেবিলের মধ্যে এমন একটি সম্পর্ক যেখানে শুধুমাত্র উভয় টেবিলের মিলিত রেকর্ডগুলি ফেরত দেওয়া হয়। LINQ to DataSet ব্যবহার করে Inner Join করা যায় যেখানে দুটি বা তার বেশি DataTable বা DataSet-এর মধ্যে মিলিত ডেটা বের করতে LINQ কুয়েরি ব্যবহার করা হয়।

LINQ to DataSet-এ Inner Join করতে join কিওয়ার্ড ব্যবহৃত হয়, যা দুইটি ডেটাসেট বা DataTable-কে নির্দিষ্ট একটি কলামের ভিত্তিতে মিলিত করে। নিচে একটি উদাহরণ দেওয়া হয়েছে যেখানে দুটি DataTable-এর উপর Inner Join ব্যবহার করা হয়েছে।

LINQ to DataSet-এ Inner Join এর ব্যবহার

১. উদাহরণ: পণ্যের তথ্য এবং পণ্যের অর্ডার ডেটা মেলানো

ধরা যাক, আপনার কাছে দুটি DataTable আছে:

• Products: পণ্যের তথ্য, যার মধ্যে ProductID, ProductName, Category রয়েছে।
• Orders: অর্ডার সম্পর্কিত তথ্য, যেখানে OrderID, ProductID, এবং Quantity রয়েছে।

আমরা এই দুটি টেবিলের ProductID কলামের উপর Inner Join করতে চাই।

using System;
using System.Data;
using System.Linq;

class Program
{
    static void Main()
    {
        // Products DataTable তৈরি
        DataTable products = new DataTable("Products");
        products.Columns.Add("ProductID", typeof(int));
        products.Columns.Add("ProductName", typeof(string));
        products.Columns.Add("Category", typeof(string));
        
        products.Rows.Add(1, "Product1", "Category1");
        products.Rows.Add(2, "Product2", "Category1");
        products.Rows.Add(3, "Product3", "Category2");

        // Orders DataTable তৈরি
        DataTable orders = new DataTable("Orders");
        orders.Columns.Add("OrderID", typeof(int));
        orders.Columns.Add("ProductID", typeof(int));
        orders.Columns.Add("Quantity", typeof(int));
        
        orders.Rows.Add(101, 1, 5);
        orders.Rows.Add(102, 2, 3);
        orders.Rows.Add(103, 1, 7);
        orders.Rows.Add(104, 3, 2);

        // LINQ কুয়েরি দিয়ে Inner Join করা
        var joinQuery = from product in products.AsEnumerable()
                        join order in orders.AsEnumerable()
                        on product.Field<int>("ProductID") equals order.Field<int>("ProductID")
                        select new
                        {
                            ProductName = product.Field<string>("ProductName"),
                            Category = product.Field<string>("Category"),
                            OrderID = order.Field<int>("OrderID"),
                            Quantity = order.Field<int>("Quantity")
                        };

        // Inner Join এর ফলাফল প্রিন্ট করা
        foreach (var item in joinQuery)
        {
            Console.WriteLine($"Product: {item.ProductName}, Category: {item.Category}, OrderID: {item.OrderID}, Quantity: {item.Quantity}");
        }
    }
}

আউটপুট:

Product: Product1, Category: Category1, OrderID: 101, Quantity: 5
Product: Product1, Category: Category1, OrderID: 103, Quantity: 7
Product: Product2, Category: Category1, OrderID: 102, Quantity: 3
Product: Product3, Category: Category2, OrderID: 104, Quantity: 2

এখানে Products এবং Orders টেবিলের মধ্যে ProductID কলামের উপর Inner Join করা হয়েছে। শুধুমাত্র সেই রেকর্ডগুলো ফলস্বরূপ আসবে যেখানে উভয় টেবিলের মধ্যে মিল রয়েছে।

Inner Join এর গুরুত্বপূর্ণ পয়েন্ট:

• Join Condition: on কিওয়ার্ড ব্যবহার করে দুইটি টেবিলের মধ্যে মিলিত হওয়া কন্ডিশন নির্ধারণ করা হয়।
• Multiple Joins: একাধিক টেবিলের মধ্যেও Join করা যেতে পারে, যেমন দুটি বা তার বেশি টেবিলের তথ্য একত্রিত করা।
• Anonymous Type: এখানে select new ব্যবহার করে একাধিক কলাম একটি অ্যানোনিমাস টাইপে রিটার্ন করা হয়, যা প্রয়োজনে একটি নতুন অবজেক্টে মেলে দেখানো হয়।

LINQ to DataSet-এ Multiple Join

আপনি একাধিক টেবিলের সাথে Inner Join করতে চাইলে আরও বেশি join ক্লজ ব্যবহার করতে পারেন। নিচে তিনটি টেবিলের মধ্যে Inner Join করার উদাহরণ দেখানো হল।

using System;
using System.Data;
using System.Linq;

class Program
{
    static void Main()
    {
        // Products DataTable
        DataTable products = new DataTable("Products");
        products.Columns.Add("ProductID", typeof(int));
        products.Columns.Add("ProductName", typeof(string));
        
        products.Rows.Add(1, "Product1");
        products.Rows.Add(2, "Product2");
        
        // Orders DataTable
        DataTable orders = new DataTable("Orders");
        orders.Columns.Add("OrderID", typeof(int));
        orders.Columns.Add("ProductID", typeof(int));
        
        orders.Rows.Add(101, 1);
        orders.Rows.Add(102, 2);
        
        // Customers DataTable
        DataTable customers = new DataTable("Customers");
        customers.Columns.Add("CustomerID", typeof(int));
        customers.Columns.Add("CustomerName", typeof(string));
        
        customers.Rows.Add(1, "Customer1");
        customers.Rows.Add(2, "Customer2");

        // LINQ Query with Multiple Joins
        var joinQuery = from product in products.AsEnumerable()
                        join order in orders.AsEnumerable()
                        on product.Field<int>("ProductID") equals order.Field<int>("ProductID")
                        join customer in customers.AsEnumerable()
                        on order.Field<int>("OrderID") equals customer.Field<int>("CustomerID")
                        select new
                        {
                            ProductName = product.Field<string>("ProductName"),
                            CustomerName = customer.Field<string>("CustomerName"),
                            OrderID = order.Field<int>("OrderID")
                        };

        // Multiple Join Results
        foreach (var item in joinQuery)
        {
            Console.WriteLine($"Product: {item.ProductName}, Customer: {item.CustomerName}, OrderID: {item.OrderID}");
        }
    }
}

এই উদাহরণে Products, Orders, এবং Customers টেবিলের মধ্যে Inner Join ব্যবহার করা হয়েছে এবং তিনটি টেবিলের তথ্য একত্রে আনা হয়েছে।

LINQ-এ Join অপারেটরটি ব্যবহার করে দুটি বা তার বেশি ডেটা সোর্সকে একত্রিত করা যায়। তবে, যখন Group Join এবং Nested Join এর মতো কৌশল ব্যবহার করা হয়, তখন একটু ভিন্ন ধরনের ফলাফল পাওয়া যায়। এখানে আমরা Group Join এবং Nested Join এর মধ্যে পার্থক্য এবং তাদের ব্যবহার দেখব।

Group Join in LINQ

Group Join হল LINQ-এর একটি বিশেষ ধরনের জয়েন অপারেশন যা একটি টেবিলের প্রতিটি রেকর্ডের জন্য অন্য টেবিলের একাধিক রেকর্ড গ্রুপ করে। এর মাধ্যমে আপনি একটি one-to-many সম্পর্ক তৈরি করতে পারেন। এটি মূলত একটি left outer join এর মত কাজ করে যেখানে মূল (left) টেবিলের সব রেকর্ড থাকবে এবং তাদের সাথে সম্পর্কিত রেকর্ডগুলো গ্রুপ করা হবে।

Group Join সাধারণত into কিওয়ার্ডের সাথে ব্যবহার করা হয়, যাতে একটি গ্রুপ এক্সপ্রেশন তৈরি হয়, যা পরে select ব্লকে অ্যাক্সেস করা যায়।

Group Join এর সিনট্যাক্স

var result = from left in leftCollection
             join right in rightCollection on left.Key equals right.Key into groupResult
             select new { left, Group = groupResult };

এখানে:

• leftCollection: প্রধান কোলেকশন বা টেবিল।
• rightCollection: যোগ করা কোলেকশন বা টেবিল।
• groupResult: দুটি কোলেকশনের সম্পর্কিত মানগুলোর একটি গ্রুপ।

Group Join এর উদাহরণ

class Customer
{
    public int CustomerID { get; set; }
    public string Name { get; set; }
}

class Order
{
    public int OrderID { get; set; }
    public int CustomerID { get; set; }
    public string Product { get; set; }
}

List<Customer> customers = new List<Customer>
{
    new Customer { CustomerID = 1, Name = "Alice" },
    new Customer { CustomerID = 2, Name = "Bob" },
    new Customer { CustomerID = 3, Name = "Charlie" }
};

List<Order> orders = new List<Order>
{
    new Order { OrderID = 101, CustomerID = 1, Product = "Laptop" },
    new Order { OrderID = 102, CustomerID = 1, Product = "Phone" },
    new Order { OrderID = 103, CustomerID = 2, Product = "Tablet" }
};

// Group Join এর ব্যবহার
var customerOrders = from customer in customers
                     join order in orders on customer.CustomerID equals order.CustomerID into customerGroup
                     select new 
                     { 
                         customer.Name,
                         Orders = customerGroup
                     };

foreach (var customer in customerOrders)
{
    Console.WriteLine($"{customer.Name} has the following orders:");
    foreach (var order in customer.Orders)
    {
        Console.WriteLine($"- {order.Product}");
    }
}
// Output:
// Alice has the following orders:
// - Laptop
// - Phone
// Bob has the following orders:
// - Tablet
// Charlie has the following orders:

এখানে:

• Group Join ব্যবহার করে প্রতিটি Customer এর সাথে তার সমস্ত অর্ডার গ্রুপ করা হয়েছে।
• Charlie এর কোন অর্ডার নেই, তাই সে শুধু তার নামের সাথে কোনো অর্ডার ছাড়াই দেখাবে।

Nested Join in LINQ

Nested Join হল LINQ এর একটি স্টাইল যেখানে একাধিক join অপারেশনকে একত্রিত করা হয় এবং তা nested query হিসাবে তৈরি করা হয়। এটি একধরনের join within a join এবং সাধারণত multiple tables এর মধ্যে সম্পর্ক তৈরি করার জন্য ব্যবহৃত হয়।

এখানে, আমরা প্রথমে একটি সাধারণ join করি, তারপর সেই join এর মধ্যে আরেকটি join করি।

Nested Join এর সিনট্যাক্স

var result = from a in collection1
             join b in collection2 on a.Key equals b.Key
             join c in collection3 on b.Key equals c.Key
             select new { a, b, c };

এখানে:

• প্রথমে collection1 এবং collection2 এর মধ্যে একটি join হবে।
• তারপর, সেই join এর ভিতরে collection3 এর সাথে আরেকটি join হবে।

Nested Join এর উদাহরণ

class Customer
{
    public int CustomerID { get; set; }
    public string Name { get; set; }
}

class Order
{
    public int OrderID { get; set; }
    public int CustomerID { get; set; }
    public string Product { get; set; }
}

class Product
{
    public int ProductID { get; set; }
    public string ProductName { get; set; }
}

List<Customer> customers = new List<Customer>
{
    new Customer { CustomerID = 1, Name = "Alice" },
    new Customer { CustomerID = 2, Name = "Bob" }
};

List<Order> orders = new List<Order>
{
    new Order { OrderID = 101, CustomerID = 1, Product = "Laptop" },
    new Order { OrderID = 102, CustomerID = 1, Product = "Phone" },
    new Order { OrderID = 103, CustomerID = 2, Product = "Tablet" }
};

List<Product> products = new List<Product>
{
    new Product { ProductID = 1, ProductName = "Laptop" },
    new Product { ProductID = 2, ProductName = "Phone" },
    new Product { ProductID = 3, ProductName = "Tablet" }
};

// Nested Join ব্যবহার করা
var customerOrders = from customer in customers
                     join order in orders on customer.CustomerID equals order.CustomerID
                     join product in products on order.Product equals product.ProductName
                     select new 
                     {
                         customer.Name,
                         order.OrderID,
                         product.ProductName
                     };

foreach (var order in customerOrders)
{
    Console.WriteLine($"{order.Name} ordered {order.ProductName} with OrderID: {order.OrderID}");
}
// Output:
// Alice ordered Laptop with OrderID: 101
// Alice ordered Phone with OrderID: 102
// Bob ordered Tablet with OrderID: 103

এখানে:

• প্রথমে Customer এবং Order এর মধ্যে join হয়েছে।
• তারপর সেই join এর মধ্যে Order এবং Product এর মধ্যে আরেকটি join হয়েছে।
• প্রতিটি গ্রাহক তার অর্ডার এবং অর্ডার করা পণ্যের নামসহ প্রিন্ট করা হয়েছে।

Group Join এবং Nested Join এর মধ্যে পার্থক্য

সারাংশ

• Group Join ব্যবহার করে one-to-many সম্পর্ক তৈরি করা যায় এবং এটি left outer join এর মতো কাজ করে যেখানে একটী রেকর্ডের সাথে একাধিক সম্পর্কিত রেকর্ড গ্রুপ করা হয়।
• Nested Join একাধিক টেবিল বা কোলেকশনের মধ্যে সম্পর্ক তৈরি করার জন্য ব্যবহৃত হয়, যা সাধারণত একাধিক join অপারেশন একসাথে একত্রিত করে।

LINQ এ Group Join এবং Nested Join উভয় পদ্ধতি আপনাকে আপনার ডেটা আরো গভীরভাবে সম্পর্কিত করে কাজ করার সুযোগ দেয়।

Left Join এবং Cross Join হল SQL এবং LINQ-এ ব্যবহৃত দুটি ভিন্ন ধরনের জয়েন অপারেশন। এগুলি ডেটাবেস থেকে ডেটা যুক্ত করার জন্য ব্যবহৃত হয়, তবে তাদের কাজের ধরন এবং ফলাফল ভিন্ন।

Left Join

Left Join হল একটি জয়েন টাইপ যেখানে প্রথম টেবিলের সব রেকর্ড (বাম পাশে থাকা টেবিল) এবং দ্বিতীয় টেবিলের সেগুলি রেকর্ড নেয়া হয় যা প্রথম টেবিলের সঙ্গে মেলে। যদি দ্বিতীয় টেবিলে কোনও মেলানো রেকর্ড না থাকে, তবে সেই ক্ষেত্রের জন্য NULL মান ব্যবহার করা হয়। এটি সাধারণত Left Outer Join নামে পরিচিত।

Left Join এর মাধ্যমে আপনি বাম টেবিলের সমস্ত ডেটা এবং মিলে যাওয়া ডান টেবিলের ডেটা পেতে পারেন।

Left Join এর সিনট্যাক্স (SQL):

SELECT table1.column1, table1.column2, table2.column1
FROM table1
LEFT JOIN table2
ON table1.common_field = table2.common_field;

এখানে, table1 এবং table2 হল দুটি টেবিল, এবং common_field হল সেই ফিল্ড যা উভয় টেবিলে মিলিয়ে রেকর্ডগুলো জয়েন করা হয়।

Left Join এর উদাহরণ

ধরা যাক, আমাদের দুটি টেবিল আছে: Customers এবং Orders। আমরা Customers টেবিলের সমস্ত ডেটা এবং তাদের Orders টেবিল থেকে অর্ডার সম্পর্কিত ডেটা বের করতে চাই।

Customers টেবিল:

Orders টেবিল:

SQL Query:

SELECT Customers.CustomerID, Customers.CustomerName, Orders.OrderAmount
FROM Customers
LEFT JOIN Orders
ON Customers.CustomerID = Orders.CustomerID;

ফলাফল:

এখানে, Charlie গ্রাহকের কোন অর্ডার নেই, তাই তার জন্য OrderAmount NULL হয়ে গেছে।

Cross Join

Cross Join হল একটি জয়েন টাইপ যা দুটি টেবিলের মধ্যে Cartesian Product তৈরি করে। অর্থাৎ, এটি প্রথম টেবিলের প্রতিটি রেকর্ডের সঙ্গে দ্বিতীয় টেবিলের প্রতিটি রেকর্ড যুক্ত করে। এই জয়েনের ফলে যে সংখ্যা তৈরি হয় তা হবে প্রথম টেবিলের রেকর্ডের সংখ্যা গুণ দ্বিতীয় টেবিলের রেকর্ডের সংখ্যা।

Cross Join এর মাধ্যমে আপনি কোন শর্ত ছাড়াই সমস্ত সম্ভাব্য রেকর্ডের সংমিশ্রণ দেখতে পাবেন।

Cross Join এর সিনট্যাক্স (SQL):

SELECT table1.column1, table2.column1
FROM table1
CROSS JOIN table2;

এখানে, table1 এবং table2 হল দুটি টেবিল। CROSS JOIN ব্যবহারের মাধ্যমে আমরা উভয় টেবিলের সব রেকর্ডের সংমিশ্রণ পেয়ে থাকি।

Cross Join এর উদাহরণ

ধরা যাক, আমাদের দুটি টেবিল আছে: Colors এবং Sizes। আমরা Colors এবং Sizes টেবিলের মধ্যে সব সম্ভাব্য সংমিশ্রণ দেখতে চাই।

Colors টেবিল:

Sizes টেবিল:

SQL Query:

SELECT Colors.Color, Sizes.Size
FROM Colors
CROSS JOIN Sizes;

ফলাফল:

এখানে, Colors এবং Sizes টেবিলের সমস্ত রেকর্ডের সংমিশ্রণ তৈরি হয়েছে।

Left Join এবং Cross Join এর মধ্যে পার্থক্য

• Left Join-এ বাম টেবিলের সব রেকর্ড থাকবে এবং যেসব রেকর্ড ডান টেবিলের সাথে মেলে, তাদের সংযুক্ত করা হবে। যেসব রেকর্ড ডান টেবিলের সাথে মেলে না, তাদের জন্য NULL মান দেখা যাবে।
• Cross Join-এ কোনো শর্ত নেই, এবং এটি দুটি টেবিলের Cartesian Product তৈরি করে, যার ফলে প্রথম টেবিলের প্রতিটি রেকর্ডের সাথে দ্বিতীয় টেবিলের প্রতিটি রেকর্ড মিলিত হয়।

LINQ-এ Left Join

LINQ-এ Left Join করার জন্য Group Join পদ্ধতি ব্যবহার করা হয়। এটি মূলত Left Outer Join এর সমতুল্য। এখানে একটি উদাহরণ দেওয়া হল:

var leftJoin = from customer in customers
               join order in orders on customer.CustomerID equals order.CustomerID into customerOrders
               from order in customerOrders.DefaultIfEmpty()
               select new
               {
                   customer.CustomerID,
                   customer.CustomerName,
                   OrderAmount = order?.OrderAmount ?? 0
               };

foreach (var item in leftJoin)
{
    Console.WriteLine($"CustomerID: {item.CustomerID}, CustomerName: {item.CustomerName}, OrderAmount: {item.OrderAmount}");
}

এখানে, DefaultIfEmpty() ব্যবহার করা হয়েছে যাতে NULL মান দেয়া যায় যদি কোনো অর্ডার না থাকে।

LINQ-এ Cross Join

LINQ-এ Cross Join তৈরি করার জন্য SelectMany পদ্ধতি ব্যবহার করা হয়। এটি প্রথম টেবিলের সব রেকর্ডের সাথে দ্বিতীয় টেবিলের সব রেকর্ডের সংমিশ্রণ তৈরি করে।

var crossJoin = from color in colors
                from size in sizes
                select new { color, size };

foreach (var item in crossJoin)
{
    Console.WriteLine($"Color: {item.color}, Size: {item.size}");
}

এখানে, প্রথম টেবিল colors এবং দ্বিতীয় টেবিল sizes এর সব রেকর্ডের সংমিশ্রণ তৈরি হয়েছে।

সারাংশ

• Left Join: বাম টেবিলের সমস্ত রেকর্ড এবং ডান টেবিলের মেলানো রেকর্ডগুলি ফেরত দেয়, যেখানে ডান টেবিলের মেলানো রেকর্ড না থাকলে NULL দেখানো হয়।
• Cross Join: দুটি টেবিলের মধ্যে সব সম্ভাব্য সংমিশ্রণ তৈরি করে। এটি Cartesian Product তৈরি করে এবং কোনো শর্ত থাকে না।

LINQ (Language Integrated Query) আপনাকে ডেটা সংগ্রহের জন্য একাধিক উত্স থেকে ডেটা একত্রিত করতে Join অপারেশন ব্যবহার করার সুযোগ দেয়। যখন ডেটার মধ্যে একাধিক সম্পর্ক থাকে, তখন Multiple Joins ব্যবহার করে একাধিক টেবিল বা কালেকশনের মধ্যে সম্পর্ক স্থাপন করা হয়। এতে আরও জটিল এবং শক্তিশালী Complex Queries লেখা সম্ভব হয়।

Multiple Joins in LINQ

Multiple Joins LINQ-এ একাধিক কালেকশন বা টেবিলের মধ্যে সম্পর্ক স্থাপন করতে ব্যবহৃত হয়, যেন একাধিক সোর্স থেকে তথ্য একত্রিত করা যায়। LINQ-এ একাধিক টেবিল বা কালেকশনকে Join করতে হলে, join কিওয়ার্ডটি ব্যবহার করা হয় এবং তারপরে প্রতিটি যোগ করা সোর্সের সাথে সম্পর্ক স্থাপন করা হয়।

বিশেষত্ব:

• একাধিক Join ব্যবহার করা সম্ভব।
• প্রতিটি Join সম্পর্কিত শর্ত সংজ্ঞায়িত করা হয়।
• এই কৌশলটি মূলত Inner Join, Left Join ইত্যাদির মতো SQL অপারেশনগুলোকে সমর্থন করে।

Multiple Joins এর উদাহরণ

ধরা যাক, আমাদের কাছে তিনটি কালেকশন: Students, Courses এবং Enrollments (যেখানে Enrollments কালেকশনটি ছাত্র এবং কোর্সের সম্পর্কের ডেটা ধারণ করে)। আমরা চাই ছাত্রদের নাম, কোর্সের নাম এবং তাদের নামকরণ অনুযায়ী কোর্সের নাম দেখতে।

// Sample Data
var students = new List<Student>
{
    new Student { StudentID = 1, Name = "John" },
    new Student { StudentID = 2, Name = "Jane" },
    new Student { StudentID = 3, Name = "Bob" }
};

var courses = new List<Course>
{
    new Course { CourseID = 1, CourseName = "Math" },
    new Course { CourseID = 2, CourseName = "Science" },
    new Course { CourseID = 3, CourseName = "History" }
};

var enrollments = new List<Enrollment>
{
    new Enrollment { StudentID = 1, CourseID = 1 },
    new Enrollment { StudentID = 1, CourseID = 2 },
    new Enrollment { StudentID = 2, CourseID = 3 },
    new Enrollment { StudentID = 3, CourseID = 2 }
};

// Multiple Join ব্যবহার করে Student, Course এবং Enrollment সম্পর্কিত ডেটা একত্রিত করা
var query = from student in students
            join enrollment in enrollments on student.StudentID equals enrollment.StudentID
            join course in courses on enrollment.CourseID equals course.CourseID
            select new
            {
                student.Name,
                course.CourseName
            };

foreach (var item in query)
{
    Console.WriteLine($"{item.Name} - {item.CourseName}");
}

Output:

John - Math
John - Science
Jane - History
Bob - Science

এখানে তিনটি কালেকশন (Students, Courses, এবং Enrollments) একত্রিত করতে Multiple Joins ব্যবহার করা হয়েছে। ছাত্রদের নাম এবং কোর্সের নাম সম্পর্কিত ডেটা পাওয়া গেছে।

Complex Queries in LINQ

Complex Queries LINQ-এ এমন কুয়েরি যা একাধিক অপারেশন যেমন Join, GroupBy, Where, OrderBy, Select, Projection এবং অন্যান্য ফাংশন একত্রে ব্যবহার করে তৈরি করা হয়। এই ধরনের কুয়েরি ব্যবহারকারীদেরকে বিভিন্ন সোর্স থেকে ডেটা সংগ্রহ এবং বিশ্লেষণ করতে সহায়ক হয়।

বিশেষত্ব:

• একাধিক অপারেশন একত্রিত করা হয়।
• ডেটা ফিল্টার, গ্রুপ, সাজানো, এবং প্রক্ষেপণ করা যায়।
• পদ্ধতি সিনট্যাক্স বা কুয়েরি সিনট্যাক্স ব্যবহার করা যেতে পারে।

Complex Query এর উদাহরণ

ধরা যাক, আমাদের একটি বিশ্ববিদ্যালয়ের ডেটা রয়েছে যেখানে ছাত্ররা কোর্সে নাম লেখায় এবং তাদের স্কোর থাকে। আমরা চাই ছাত্রদের নাম, কোর্সের নাম, এবং তাদের স্কোর জানাতে, কিন্তু শুধু সেই ছাত্রদের যাদের স্কোর ৭০ এর বেশি। এছাড়া, আমরা এই ডেটাকে কোর্সের নামে সাজাতে চাই।

// Sample Data
var students = new List<Student>
{
    new Student { StudentID = 1, Name = "John" },
    new Student { StudentID = 2, Name = "Jane" },
    new Student { StudentID = 3, Name = "Bob" }
};

var courses = new List<Course>
{
    new Course { CourseID = 1, CourseName = "Math" },
    new Course { CourseID = 2, CourseName = "Science" },
    new Course { CourseID = 3, CourseName = "History" }
};

var enrollments = new List<Enrollment>
{
    new Enrollment { StudentID = 1, CourseID = 1, Score = 85 },
    new Enrollment { StudentID = 1, CourseID = 2, Score = 90 },
    new Enrollment { StudentID = 2, CourseID = 1, Score = 60 },
    new Enrollment { StudentID = 2, CourseID = 3, Score = 70 },
    new Enrollment { StudentID = 3, CourseID = 2, Score = 75 }
};

// Complex Query: Multiple Joins, Where, OrderBy, and Select
var query = from student in students
            join enrollment in enrollments on student.StudentID equals enrollment.StudentID
            join course in courses on enrollment.CourseID equals course.CourseID
            where enrollment.Score > 70
            orderby course.CourseName
            select new
            {
                student.Name,
                course.CourseName,
                enrollment.Score
            };

foreach (var item in query)
{
    Console.WriteLine($"{item.Name} - {item.CourseName} - {item.Score}");
}

Output:

John - Math - 85
John - Science - 90
Bob - Science - 75

এখানে Complex Query তৈরি করতে আমরা একাধিক Join, Where, OrderBy এবং Select ব্যবহার করেছি। এই কুয়েরি ছাত্রদের নাম, কোর্সের নাম এবং তাদের স্কোর বের করেছে, তবে শুধু সেই ছাত্রদের যে স্কোর ৭০ এর বেশি।

Conclusion

• Multiple Joins LINQ-এ একাধিক সোর্স থেকে ডেটা একত্রিত করতে ব্যবহৃত হয়। এটি SQL-এর Inner Join এবং Left Join অপারেশনের মতো কাজ করে।
• Complex Queries একাধিক LINQ অপারেশন একত্রিত করে তৈরি করা হয়, যা ডেটা ফিল্টার, গ্রুপ, সাজানো এবং প্রক্ষেপণের জন্য ব্যবহৃত হয়।
• LINQ-এ Join এবং Projection একসাথে ব্যবহার করে আপনি Nested Data কে ফ্ল্যাট করে, এবং জটিল ডেটা সম্পর্ক তৈরি করতে পারেন।

LINQ এর এই শক্তিশালী বৈশিষ্ট্যগুলির সাহায্যে, আপনি ডেটাবেস বা অন্য কোন সোর্স থেকে ডেটা নিয়ে খুব সহজেই জটিল কুয়েরি তৈরি এবং এক্সিকিউট করতে পারেন।